home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / test_re.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  30KB  |  816 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. import sys
  5. sys.path = [
  6.     '.'] + sys.path
  7. from test.test_support import verbose, run_unittest
  8. import re
  9. from sre import Scanner
  10. import sys
  11. import os
  12. import traceback
  13. from weakref import proxy
  14. import unittest
  15.  
  16. class ReTests(unittest.TestCase):
  17.     
  18.     def test_weakref(self):
  19.         s = 'QabbbcR'
  20.         x = re.compile('ab+c')
  21.         y = proxy(x)
  22.         self.assertEqual(x.findall('QabbbcR'), y.findall('QabbbcR'))
  23.  
  24.     
  25.     def test_search_star_plus(self):
  26.         self.assertEqual(re.search('x*', 'axx').span(0), (0, 0))
  27.         self.assertEqual(re.search('x*', 'axx').span(), (0, 0))
  28.         self.assertEqual(re.search('x+', 'axx').span(0), (1, 3))
  29.         self.assertEqual(re.search('x+', 'axx').span(), (1, 3))
  30.         self.assertEqual(re.search('x', 'aaa'), None)
  31.         self.assertEqual(re.match('a*', 'xxx').span(0), (0, 0))
  32.         self.assertEqual(re.match('a*', 'xxx').span(), (0, 0))
  33.         self.assertEqual(re.match('x*', 'xxxa').span(0), (0, 3))
  34.         self.assertEqual(re.match('x*', 'xxxa').span(), (0, 3))
  35.         self.assertEqual(re.match('a+', 'xxx'), None)
  36.  
  37.     
  38.     def bump_num(self, matchobj):
  39.         int_value = int(matchobj.group(0))
  40.         return str(int_value + 1)
  41.  
  42.     
  43.     def test_basic_re_sub(self):
  44.         self.assertEqual(re.sub('(?i)b+', 'x', 'bbbb BBBB'), 'x x')
  45.         self.assertEqual(re.sub('\\d+', self.bump_num, '08.2 -2 23x99y'), '9.3 -3 24x100y')
  46.         self.assertEqual(re.sub('\\d+', self.bump_num, '08.2 -2 23x99y', 3), '9.3 -3 23x99y')
  47.         self.assertEqual(re.sub('.', (lambda m: '\\n'), 'x'), '\\n')
  48.         self.assertEqual(re.sub('.', '\\n', 'x'), '\n')
  49.         s = '\\1\\1'
  50.         self.assertEqual(re.sub('(.)', s, 'x'), 'xx')
  51.         self.assertEqual(re.sub('(.)', re.escape(s), 'x'), s)
  52.         self.assertEqual(re.sub('(.)', (lambda m: s), 'x'), s)
  53.         self.assertEqual(re.sub('(?P<a>x)', '\\g<a>\\g<a>', 'xx'), 'xxxx')
  54.         self.assertEqual(re.sub('(?P<a>x)', '\\g<a>\\g<1>', 'xx'), 'xxxx')
  55.         self.assertEqual(re.sub('(?P<unk>x)', '\\g<unk>\\g<unk>', 'xx'), 'xxxx')
  56.         self.assertEqual(re.sub('(?P<unk>x)', '\\g<1>\\g<1>', 'xx'), 'xxxx')
  57.         self.assertEqual(re.sub('a', '\\t\\n\\v\\r\\f\\a\\b\\B\\Z\\a\\A\\w\\W\\s\\S\\d\\D', 'a'), '\t\n\x0b\r\x0c\x07\x08\\B\\Z\x07\\A\\w\\W\\s\\S\\d\\D')
  58.         self.assertEqual(re.sub('a', '\t\n\x0b\r\x0c\x07', 'a'), '\t\n\x0b\r\x0c\x07')
  59.         self.assertEqual(re.sub('a', '\t\n\x0b\r\x0c\x07', 'a'), chr(9) + chr(10) + chr(11) + chr(13) + chr(12) + chr(7))
  60.         self.assertEqual(re.sub('^\\s*', 'X', 'test'), 'Xtest')
  61.  
  62.     
  63.     def test_bug_449964(self):
  64.         self.assertEqual(re.sub('(?P<unk>x)', '\\g<1>\\g<1>\\b', 'xx'), 'xx\x08xx\x08')
  65.  
  66.     
  67.     def test_bug_449000(self):
  68.         self.assertEqual(re.sub('\\r\\n', '\\n', 'abc\r\ndef\r\n'), 'abc\ndef\n')
  69.         self.assertEqual(re.sub('\r\n', '\\n', 'abc\r\ndef\r\n'), 'abc\ndef\n')
  70.         self.assertEqual(re.sub('\\r\\n', '\n', 'abc\r\ndef\r\n'), 'abc\ndef\n')
  71.         self.assertEqual(re.sub('\r\n', '\n', 'abc\r\ndef\r\n'), 'abc\ndef\n')
  72.  
  73.     
  74.     def test_sub_template_numeric_escape(self):
  75.         self.assertEqual(re.sub('x', '\\0', 'x'), '\x00')
  76.         self.assertEqual(re.sub('x', '\\000', 'x'), '\x00')
  77.         self.assertEqual(re.sub('x', '\\001', 'x'), '\x01')
  78.         self.assertEqual(re.sub('x', '\\008', 'x'), '\x00' + '8')
  79.         self.assertEqual(re.sub('x', '\\009', 'x'), '\x00' + '9')
  80.         self.assertEqual(re.sub('x', '\\111', 'x'), 'I')
  81.         self.assertEqual(re.sub('x', '\\117', 'x'), 'O')
  82.         self.assertEqual(re.sub('x', '\\1111', 'x'), 'I1')
  83.         self.assertEqual(re.sub('x', '\\1111', 'x'), 'I' + '1')
  84.         self.assertEqual(re.sub('x', '\\00', 'x'), '\x00')
  85.         self.assertEqual(re.sub('x', '\\07', 'x'), '\x07')
  86.         self.assertEqual(re.sub('x', '\\08', 'x'), '\x00' + '8')
  87.         self.assertEqual(re.sub('x', '\\09', 'x'), '\x00' + '9')
  88.         self.assertEqual(re.sub('x', '\\0a', 'x'), '\x00' + 'a')
  89.         self.assertEqual(re.sub('x', '\\400', 'x'), '\x00')
  90.         self.assertEqual(re.sub('x', '\\777', 'x'), '\xff')
  91.         self.assertRaises(re.error, re.sub, 'x', '\\1', 'x')
  92.         self.assertRaises(re.error, re.sub, 'x', '\\8', 'x')
  93.         self.assertRaises(re.error, re.sub, 'x', '\\9', 'x')
  94.         self.assertRaises(re.error, re.sub, 'x', '\\11', 'x')
  95.         self.assertRaises(re.error, re.sub, 'x', '\\18', 'x')
  96.         self.assertRaises(re.error, re.sub, 'x', '\\1a', 'x')
  97.         self.assertRaises(re.error, re.sub, 'x', '\\90', 'x')
  98.         self.assertRaises(re.error, re.sub, 'x', '\\99', 'x')
  99.         self.assertRaises(re.error, re.sub, 'x', '\\118', 'x')
  100.         self.assertRaises(re.error, re.sub, 'x', '\\11a', 'x')
  101.         self.assertRaises(re.error, re.sub, 'x', '\\181', 'x')
  102.         self.assertRaises(re.error, re.sub, 'x', '\\800', 'x')
  103.         self.assertEqual(re.sub('(((((((((((x)))))))))))', '\\11', 'x'), 'x')
  104.         self.assertEqual(re.sub('((((((((((y))))))))))(.)', '\\118', 'xyz'), 'xz8')
  105.         self.assertEqual(re.sub('((((((((((y))))))))))(.)', '\\11a', 'xyz'), 'xza')
  106.  
  107.     
  108.     def test_qualified_re_sub(self):
  109.         self.assertEqual(re.sub('a', 'b', 'aaaaa'), 'bbbbb')
  110.         self.assertEqual(re.sub('a', 'b', 'aaaaa', 1), 'baaaa')
  111.  
  112.     
  113.     def test_bug_114660(self):
  114.         self.assertEqual(re.sub('(\\S)\\s+(\\S)', '\\1 \\2', 'hello  there'), 'hello there')
  115.  
  116.     
  117.     def test_bug_462270(self):
  118.         self.assertEqual(re.sub('x*', '-', 'abxd'), '-a-b-d-')
  119.         self.assertEqual(re.sub('x+', '-', 'abxd'), 'ab-d')
  120.  
  121.     
  122.     def test_symbolic_refs(self):
  123.         self.assertRaises(re.error, re.sub, '(?P<a>x)', '\\g<a', 'xx')
  124.         self.assertRaises(re.error, re.sub, '(?P<a>x)', '\\g<', 'xx')
  125.         self.assertRaises(re.error, re.sub, '(?P<a>x)', '\\g', 'xx')
  126.         self.assertRaises(re.error, re.sub, '(?P<a>x)', '\\g<a a>', 'xx')
  127.         self.assertRaises(re.error, re.sub, '(?P<a>x)', '\\g<1a1>', 'xx')
  128.         self.assertRaises(IndexError, re.sub, '(?P<a>x)', '\\g<ab>', 'xx')
  129.         self.assertRaises(re.error, re.sub, '(?P<a>x)|(?P<b>y)', '\\g<b>', 'xx')
  130.         self.assertRaises(re.error, re.sub, '(?P<a>x)|(?P<b>y)', '\\2', 'xx')
  131.         self.assertRaises(re.error, re.sub, '(?P<a>x)', '\\g<-1>', 'xx')
  132.  
  133.     
  134.     def test_re_subn(self):
  135.         self.assertEqual(re.subn('(?i)b+', 'x', 'bbbb BBBB'), ('x x', 2))
  136.         self.assertEqual(re.subn('b+', 'x', 'bbbb BBBB'), ('x BBBB', 1))
  137.         self.assertEqual(re.subn('b+', 'x', 'xyz'), ('xyz', 0))
  138.         self.assertEqual(re.subn('b*', 'x', 'xyz'), ('xxxyxzx', 4))
  139.         self.assertEqual(re.subn('b*', 'x', 'xyz', 2), ('xxxyz', 2))
  140.  
  141.     
  142.     def test_re_split(self):
  143.         self.assertEqual(re.split(':', ':a:b::c'), [
  144.             '',
  145.             'a',
  146.             'b',
  147.             '',
  148.             'c'])
  149.         self.assertEqual(re.split(':*', ':a:b::c'), [
  150.             '',
  151.             'a',
  152.             'b',
  153.             'c'])
  154.         self.assertEqual(re.split('(:*)', ':a:b::c'), [
  155.             '',
  156.             ':',
  157.             'a',
  158.             ':',
  159.             'b',
  160.             '::',
  161.             'c'])
  162.         self.assertEqual(re.split('(?::*)', ':a:b::c'), [
  163.             '',
  164.             'a',
  165.             'b',
  166.             'c'])
  167.         self.assertEqual(re.split('(:)*', ':a:b::c'), [
  168.             '',
  169.             ':',
  170.             'a',
  171.             ':',
  172.             'b',
  173.             ':',
  174.             'c'])
  175.         self.assertEqual(re.split('([b:]+)', ':a:b::c'), [
  176.             '',
  177.             ':',
  178.             'a',
  179.             ':b::',
  180.             'c'])
  181.         self.assertEqual(re.split('(b)|(:+)', ':a:b::c'), [
  182.             '',
  183.             None,
  184.             ':',
  185.             'a',
  186.             None,
  187.             ':',
  188.             '',
  189.             'b',
  190.             None,
  191.             '',
  192.             None,
  193.             '::',
  194.             'c'])
  195.         self.assertEqual(re.split('(?:b)|(?::+)', ':a:b::c'), [
  196.             '',
  197.             'a',
  198.             '',
  199.             '',
  200.             'c'])
  201.  
  202.     
  203.     def test_qualified_re_split(self):
  204.         self.assertEqual(re.split(':', ':a:b::c', 2), [
  205.             '',
  206.             'a',
  207.             'b::c'])
  208.         self.assertEqual(re.split(':', 'a:b:c:d', 2), [
  209.             'a',
  210.             'b',
  211.             'c:d'])
  212.         self.assertEqual(re.split('(:)', ':a:b::c', 2), [
  213.             '',
  214.             ':',
  215.             'a',
  216.             ':',
  217.             'b::c'])
  218.         self.assertEqual(re.split('(:*)', ':a:b::c', 2), [
  219.             '',
  220.             ':',
  221.             'a',
  222.             ':',
  223.             'b::c'])
  224.  
  225.     
  226.     def test_re_findall(self):
  227.         self.assertEqual(re.findall(':+', 'abc'), [])
  228.         self.assertEqual(re.findall(':+', 'a:b::c:::d'), [
  229.             ':',
  230.             '::',
  231.             ':::'])
  232.         self.assertEqual(re.findall('(:+)', 'a:b::c:::d'), [
  233.             ':',
  234.             '::',
  235.             ':::'])
  236.         self.assertEqual(re.findall('(:)(:*)', 'a:b::c:::d'), [
  237.             (':', ''),
  238.             (':', ':'),
  239.             (':', '::')])
  240.  
  241.     
  242.     def test_bug_117612(self):
  243.         self.assertEqual(re.findall('(a|(b))', 'aba'), [
  244.             ('a', ''),
  245.             ('b', 'b'),
  246.             ('a', '')])
  247.  
  248.     
  249.     def test_re_match(self):
  250.         self.assertEqual(re.match('a', 'a').groups(), ())
  251.         self.assertEqual(re.match('(a)', 'a').groups(), ('a',))
  252.         self.assertEqual(re.match('(a)', 'a').group(0), 'a')
  253.         self.assertEqual(re.match('(a)', 'a').group(1), 'a')
  254.         self.assertEqual(re.match('(a)', 'a').group(1, 1), ('a', 'a'))
  255.         pat = re.compile('((a)|(b))(c)?')
  256.         self.assertEqual(pat.match('a').groups(), ('a', 'a', None, None))
  257.         self.assertEqual(pat.match('b').groups(), ('b', None, 'b', None))
  258.         self.assertEqual(pat.match('ac').groups(), ('a', 'a', None, 'c'))
  259.         self.assertEqual(pat.match('bc').groups(), ('b', None, 'b', 'c'))
  260.         self.assertEqual(pat.match('bc').groups(''), ('b', '', 'b', 'c'))
  261.         m = re.match('(a)', 'a')
  262.         self.assertEqual(m.group(0), 'a')
  263.         self.assertEqual(m.group(0), 'a')
  264.         self.assertEqual(m.group(1), 'a')
  265.         self.assertEqual(m.group(1, 1), ('a', 'a'))
  266.         pat = re.compile('(?:(?P<a1>a)|(?P<b2>b))(?P<c3>c)?')
  267.         self.assertEqual(pat.match('a').group(1, 2, 3), ('a', None, None))
  268.         self.assertEqual(pat.match('b').group('a1', 'b2', 'c3'), (None, 'b', None))
  269.         self.assertEqual(pat.match('ac').group(1, 'b2', 3), ('a', None, 'c'))
  270.  
  271.     
  272.     def test_re_groupref_exists(self):
  273.         self.assertEqual(re.match('^(\\()?([^()]+)(?(1)\\))$', '(a)').groups(), ('(', 'a'))
  274.         self.assertEqual(re.match('^(\\()?([^()]+)(?(1)\\))$', 'a').groups(), (None, 'a'))
  275.         self.assertEqual(re.match('^(\\()?([^()]+)(?(1)\\))$', 'a)'), None)
  276.         self.assertEqual(re.match('^(\\()?([^()]+)(?(1)\\))$', '(a'), None)
  277.         self.assertEqual(re.match('^(?:(a)|c)((?(1)b|d))$', 'ab').groups(), ('a', 'b'))
  278.         self.assertEqual(re.match('^(?:(a)|c)((?(1)b|d))$', 'cd').groups(), (None, 'd'))
  279.         self.assertEqual(re.match('^(?:(a)|c)((?(1)|d))$', 'cd').groups(), (None, 'd'))
  280.         self.assertEqual(re.match('^(?:(a)|c)((?(1)|d))$', 'a').groups(), ('a', ''))
  281.         p = re.compile('(?P<g1>a)(?P<g2>b)?((?(g2)c|d))')
  282.         self.assertEqual(p.match('abc').groups(), ('a', 'b', 'c'))
  283.         self.assertEqual(p.match('ad').groups(), ('a', None, 'd'))
  284.         self.assertEqual(p.match('abd'), None)
  285.         self.assertEqual(p.match('ac'), None)
  286.  
  287.     
  288.     def test_re_groupref(self):
  289.         self.assertEqual(re.match('^(\\|)?([^()]+)\\1$', '|a|').groups(), ('|', 'a'))
  290.         self.assertEqual(re.match('^(\\|)?([^()]+)\\1?$', 'a').groups(), (None, 'a'))
  291.         self.assertEqual(re.match('^(\\|)?([^()]+)\\1$', 'a|'), None)
  292.         self.assertEqual(re.match('^(\\|)?([^()]+)\\1$', '|a'), None)
  293.         self.assertEqual(re.match('^(?:(a)|c)(\\1)$', 'aa').groups(), ('a', 'a'))
  294.         self.assertEqual(re.match('^(?:(a)|c)(\\1)?$', 'c').groups(), (None, None))
  295.  
  296.     
  297.     def test_groupdict(self):
  298.         self.assertEqual(re.match('(?P<first>first) (?P<second>second)', 'first second').groupdict(), {
  299.             'first': 'first',
  300.             'second': 'second' })
  301.  
  302.     
  303.     def test_expand(self):
  304.         self.assertEqual(re.match('(?P<first>first) (?P<second>second)', 'first second').expand('\\2 \\1 \\g<second> \\g<first>'), 'second first second first')
  305.  
  306.     
  307.     def test_repeat_minmax(self):
  308.         self.assertEqual(re.match('^(\\w){1}$', 'abc'), None)
  309.         self.assertEqual(re.match('^(\\w){1}?$', 'abc'), None)
  310.         self.assertEqual(re.match('^(\\w){1,2}$', 'abc'), None)
  311.         self.assertEqual(re.match('^(\\w){1,2}?$', 'abc'), None)
  312.         self.assertEqual(re.match('^(\\w){3}$', 'abc').group(1), 'c')
  313.         self.assertEqual(re.match('^(\\w){1,3}$', 'abc').group(1), 'c')
  314.         self.assertEqual(re.match('^(\\w){1,4}$', 'abc').group(1), 'c')
  315.         self.assertEqual(re.match('^(\\w){3,4}?$', 'abc').group(1), 'c')
  316.         self.assertEqual(re.match('^(\\w){3}?$', 'abc').group(1), 'c')
  317.         self.assertEqual(re.match('^(\\w){1,3}?$', 'abc').group(1), 'c')
  318.         self.assertEqual(re.match('^(\\w){1,4}?$', 'abc').group(1), 'c')
  319.         self.assertEqual(re.match('^(\\w){3,4}?$', 'abc').group(1), 'c')
  320.         self.assertEqual(re.match('^x{1}$', 'xxx'), None)
  321.         self.assertEqual(re.match('^x{1}?$', 'xxx'), None)
  322.         self.assertEqual(re.match('^x{1,2}$', 'xxx'), None)
  323.         self.assertEqual(re.match('^x{1,2}?$', 'xxx'), None)
  324.         self.assertNotEqual(re.match('^x{3}$', 'xxx'), None)
  325.         self.assertNotEqual(re.match('^x{1,3}$', 'xxx'), None)
  326.         self.assertNotEqual(re.match('^x{1,4}$', 'xxx'), None)
  327.         self.assertNotEqual(re.match('^x{3,4}?$', 'xxx'), None)
  328.         self.assertNotEqual(re.match('^x{3}?$', 'xxx'), None)
  329.         self.assertNotEqual(re.match('^x{1,3}?$', 'xxx'), None)
  330.         self.assertNotEqual(re.match('^x{1,4}?$', 'xxx'), None)
  331.         self.assertNotEqual(re.match('^x{3,4}?$', 'xxx'), None)
  332.         self.assertEqual(re.match('^x{}$', 'xxx'), None)
  333.         self.assertNotEqual(re.match('^x{}$', 'x{}'), None)
  334.  
  335.     
  336.     def test_getattr(self):
  337.         self.assertEqual(re.match('(a)', 'a').pos, 0)
  338.         self.assertEqual(re.match('(a)', 'a').endpos, 1)
  339.         self.assertEqual(re.match('(a)', 'a').string, 'a')
  340.         self.assertEqual(re.match('(a)', 'a').regs, ((0, 1), (0, 1)))
  341.         self.assertNotEqual(re.match('(a)', 'a').re, None)
  342.  
  343.     
  344.     def test_special_escapes(self):
  345.         self.assertEqual(re.search('\\b(b.)\\b', 'abcd abc bcd bx').group(1), 'bx')
  346.         self.assertEqual(re.search('\\B(b.)\\B', 'abc bcd bc abxd').group(1), 'bx')
  347.         self.assertEqual(re.search('\\b(b.)\\b', 'abcd abc bcd bx', re.LOCALE).group(1), 'bx')
  348.         self.assertEqual(re.search('\\B(b.)\\B', 'abc bcd bc abxd', re.LOCALE).group(1), 'bx')
  349.         self.assertEqual(re.search('\\b(b.)\\b', 'abcd abc bcd bx', re.UNICODE).group(1), 'bx')
  350.         self.assertEqual(re.search('\\B(b.)\\B', 'abc bcd bc abxd', re.UNICODE).group(1), 'bx')
  351.         self.assertEqual(re.search('^abc$', '\nabc\n', re.M).group(0), 'abc')
  352.         self.assertEqual(re.search('^\\Aabc\\Z$', 'abc', re.M).group(0), 'abc')
  353.         self.assertEqual(re.search('^\\Aabc\\Z$', '\nabc\n', re.M), None)
  354.         self.assertEqual(re.search('\\b(b.)\\b', u'abcd abc bcd bx').group(1), 'bx')
  355.         self.assertEqual(re.search('\\B(b.)\\B', u'abc bcd bc abxd').group(1), 'bx')
  356.         self.assertEqual(re.search('^abc$', u'\nabc\n', re.M).group(0), 'abc')
  357.         self.assertEqual(re.search('^\\Aabc\\Z$', u'abc', re.M).group(0), 'abc')
  358.         self.assertEqual(re.search('^\\Aabc\\Z$', u'\nabc\n', re.M), None)
  359.         self.assertEqual(re.search('\\d\\D\\w\\W\\s\\S', '1aa! a').group(0), '1aa! a')
  360.         self.assertEqual(re.search('\\d\\D\\w\\W\\s\\S', '1aa! a', re.LOCALE).group(0), '1aa! a')
  361.         self.assertEqual(re.search('\\d\\D\\w\\W\\s\\S', '1aa! a', re.UNICODE).group(0), '1aa! a')
  362.  
  363.     
  364.     def test_ignore_case(self):
  365.         self.assertEqual(re.match('abc', 'ABC', re.I).group(0), 'ABC')
  366.         self.assertEqual(re.match('abc', u'ABC', re.I).group(0), 'ABC')
  367.  
  368.     
  369.     def test_bigcharset(self):
  370.         self.assertEqual(re.match(u'([\xe2\x88\xa2\xe2\x88\xa3])', u'\xe2\x88\xa2').group(1), u'\xe2\x88\xa2')
  371.         self.assertEqual(re.match(u'([\xe2\x88\xa2\xe2\x88\xa3])', u'\xe2\x88\xa2', re.UNICODE).group(1), u'\xe2\x88\xa2')
  372.  
  373.     
  374.     def test_anyall(self):
  375.         self.assertEqual(re.match('a.b', 'a\nb', re.DOTALL).group(0), 'a\nb')
  376.         self.assertEqual(re.match('a.*b', 'a\n\nb', re.DOTALL).group(0), 'a\n\nb')
  377.  
  378.     
  379.     def test_non_consuming(self):
  380.         self.assertEqual(re.match('(a(?=\\s[^a]))', 'a b').group(1), 'a')
  381.         self.assertEqual(re.match('(a(?=\\s[^a]*))', 'a b').group(1), 'a')
  382.         self.assertEqual(re.match('(a(?=\\s[abc]))', 'a b').group(1), 'a')
  383.         self.assertEqual(re.match('(a(?=\\s[abc]*))', 'a bc').group(1), 'a')
  384.         self.assertEqual(re.match('(a)(?=\\s\\1)', 'a a').group(1), 'a')
  385.         self.assertEqual(re.match('(a)(?=\\s\\1*)', 'a aa').group(1), 'a')
  386.         self.assertEqual(re.match('(a)(?=\\s(abc|a))', 'a a').group(1), 'a')
  387.         self.assertEqual(re.match('(a(?!\\s[^a]))', 'a a').group(1), 'a')
  388.         self.assertEqual(re.match('(a(?!\\s[abc]))', 'a d').group(1), 'a')
  389.         self.assertEqual(re.match('(a)(?!\\s\\1)', 'a b').group(1), 'a')
  390.         self.assertEqual(re.match('(a)(?!\\s(abc|a))', 'a b').group(1), 'a')
  391.  
  392.     
  393.     def test_ignore_case(self):
  394.         self.assertEqual(re.match('(a\\s[^a])', 'a b', re.I).group(1), 'a b')
  395.         self.assertEqual(re.match('(a\\s[^a]*)', 'a bb', re.I).group(1), 'a bb')
  396.         self.assertEqual(re.match('(a\\s[abc])', 'a b', re.I).group(1), 'a b')
  397.         self.assertEqual(re.match('(a\\s[abc]*)', 'a bb', re.I).group(1), 'a bb')
  398.         self.assertEqual(re.match('((a)\\s\\2)', 'a a', re.I).group(1), 'a a')
  399.         self.assertEqual(re.match('((a)\\s\\2*)', 'a aa', re.I).group(1), 'a aa')
  400.         self.assertEqual(re.match('((a)\\s(abc|a))', 'a a', re.I).group(1), 'a a')
  401.         self.assertEqual(re.match('((a)\\s(abc|a)*)', 'a aa', re.I).group(1), 'a aa')
  402.  
  403.     
  404.     def test_category(self):
  405.         self.assertEqual(re.match('(\\s)', ' ').group(1), ' ')
  406.  
  407.     
  408.     def test_getlower(self):
  409.         import _sre as _sre
  410.         self.assertEqual(_sre.getlower(ord('A'), 0), ord('a'))
  411.         self.assertEqual(_sre.getlower(ord('A'), re.LOCALE), ord('a'))
  412.         self.assertEqual(_sre.getlower(ord('A'), re.UNICODE), ord('a'))
  413.         self.assertEqual(re.match('abc', 'ABC', re.I).group(0), 'ABC')
  414.         self.assertEqual(re.match('abc', u'ABC', re.I).group(0), 'ABC')
  415.  
  416.     
  417.     def test_not_literal(self):
  418.         self.assertEqual(re.search('\\s([^a])', ' b').group(1), 'b')
  419.         self.assertEqual(re.search('\\s([^a]*)', ' bb').group(1), 'bb')
  420.  
  421.     
  422.     def test_search_coverage(self):
  423.         self.assertEqual(re.search('\\s(b)', ' b').group(1), 'b')
  424.         self.assertEqual(re.search('a\\s', 'a ').group(0), 'a ')
  425.  
  426.     
  427.     def test_re_escape(self):
  428.         p = ''
  429.         for i in range(0, 256):
  430.             p = p + chr(i)
  431.             self.assertEqual(re.match(re.escape(chr(i)), chr(i)) is not None, True)
  432.             self.assertEqual(re.match(re.escape(chr(i)), chr(i)).span(), (0, 1))
  433.         
  434.         pat = re.compile(re.escape(p))
  435.         self.assertEqual(pat.match(p) is not None, True)
  436.         self.assertEqual(pat.match(p).span(), (0, 256))
  437.  
  438.     
  439.     def test_pickling(self):
  440.         import pickle as pickle
  441.         self.pickle_test(pickle)
  442.         import cPickle as cPickle
  443.         self.pickle_test(cPickle)
  444.  
  445.     
  446.     def pickle_test(self, pickle):
  447.         oldpat = re.compile('a(?:b|(c|e){1,2}?|d)+?(.)')
  448.         s = pickle.dumps(oldpat)
  449.         newpat = pickle.loads(s)
  450.         self.assertEqual(oldpat, newpat)
  451.  
  452.     
  453.     def test_constants(self):
  454.         self.assertEqual(re.I, re.IGNORECASE)
  455.         self.assertEqual(re.L, re.LOCALE)
  456.         self.assertEqual(re.M, re.MULTILINE)
  457.         self.assertEqual(re.S, re.DOTALL)
  458.         self.assertEqual(re.X, re.VERBOSE)
  459.  
  460.     
  461.     def test_flags(self):
  462.         for flag in [
  463.             re.I,
  464.             re.M,
  465.             re.X,
  466.             re.S,
  467.             re.L]:
  468.             self.assertNotEqual(re.compile('^pattern$', flag), None)
  469.         
  470.  
  471.     
  472.     def test_sre_character_literals(self):
  473.         for i in [
  474.             0,
  475.             8,
  476.             16,
  477.             32,
  478.             64,
  479.             127,
  480.             128,
  481.             255]:
  482.             self.assertNotEqual(re.match('\\%03o' % i, chr(i)), None)
  483.             self.assertNotEqual(re.match('\\%03o0' % i, chr(i) + '0'), None)
  484.             self.assertNotEqual(re.match('\\%03o8' % i, chr(i) + '8'), None)
  485.             self.assertNotEqual(re.match('\\x%02x' % i, chr(i)), None)
  486.             self.assertNotEqual(re.match('\\x%02x0' % i, chr(i) + '0'), None)
  487.             self.assertNotEqual(re.match('\\x%02xz' % i, chr(i) + 'z'), None)
  488.         
  489.         self.assertRaises(re.error, re.match, '\\911', '')
  490.  
  491.     
  492.     def test_sre_character_class_literals(self):
  493.         for i in [
  494.             0,
  495.             8,
  496.             16,
  497.             32,
  498.             64,
  499.             127,
  500.             128,
  501.             255]:
  502.             self.assertNotEqual(re.match('[\\%03o]' % i, chr(i)), None)
  503.             self.assertNotEqual(re.match('[\\%03o0]' % i, chr(i)), None)
  504.             self.assertNotEqual(re.match('[\\%03o8]' % i, chr(i)), None)
  505.             self.assertNotEqual(re.match('[\\x%02x]' % i, chr(i)), None)
  506.             self.assertNotEqual(re.match('[\\x%02x0]' % i, chr(i)), None)
  507.             self.assertNotEqual(re.match('[\\x%02xz]' % i, chr(i)), None)
  508.         
  509.         self.assertRaises(re.error, re.match, '[\\911]', '')
  510.  
  511.     
  512.     def test_bug_113254(self):
  513.         self.assertEqual(re.match('(a)|(b)', 'b').start(1), -1)
  514.         self.assertEqual(re.match('(a)|(b)', 'b').end(1), -1)
  515.         self.assertEqual(re.match('(a)|(b)', 'b').span(1), (-1, -1))
  516.  
  517.     
  518.     def test_bug_527371(self):
  519.         self.assertEqual(re.match('(a)?a', 'a').lastindex, None)
  520.         self.assertEqual(re.match('(a)(b)?b', 'ab').lastindex, 1)
  521.         self.assertEqual(re.match('(?P<a>a)(?P<b>b)?b', 'ab').lastgroup, 'a')
  522.         self.assertEqual(re.match('(?P<a>a(b))', 'ab').lastgroup, 'a')
  523.         self.assertEqual(re.match('((a))', 'a').lastindex, 1)
  524.  
  525.     
  526.     def test_bug_545855(self):
  527.         self.assertRaises(re.error, re.compile, 'foo[a-')
  528.  
  529.     
  530.     def test_bug_418626(self):
  531.         self.assertEqual(re.match('.*?c', 10000 * 'ab' + 'cd').end(0), 20001)
  532.         self.assertEqual(re.match('.*?cd', 5000 * 'ab' + 'c' + 5000 * 'ab' + 'cde').end(0), 20003)
  533.         self.assertEqual(re.match('.*?cd', 20000 * 'abc' + 'de').end(0), 60001)
  534.         self.assertEqual(re.search('(a|b)*?c', 10000 * 'ab' + 'cd').end(0), 20001)
  535.  
  536.     
  537.     def test_bug_612074(self):
  538.         pat = u'[' + re.escape(u'\xe2\x80\xb9') + u']'
  539.         if re.compile(pat):
  540.             pass
  541.         self.assertEqual(1, 1)
  542.  
  543.     
  544.     def test_stack_overflow(self):
  545.         self.assertEqual(re.match('(x)*', 50000 * 'x').group(1), 'x')
  546.         self.assertEqual(re.match('(x)*y', 50000 * 'x' + 'y').group(1), 'x')
  547.         self.assertEqual(re.match('(x)*?y', 50000 * 'x' + 'y').group(1), 'x')
  548.  
  549.     
  550.     def test_scanner(self):
  551.         
  552.         def s_ident(scanner, token):
  553.             return token
  554.  
  555.         
  556.         def s_operator(scanner, token):
  557.             return 'op%s' % token
  558.  
  559.         
  560.         def s_float(scanner, token):
  561.             return float(token)
  562.  
  563.         
  564.         def s_int(scanner, token):
  565.             return int(token)
  566.  
  567.         scanner = Scanner([
  568.             ('[a-zA-Z_]\\w*', s_ident),
  569.             ('\\d+\\.\\d*', s_float),
  570.             ('\\d+', s_int),
  571.             ('=|\\+|-|\\*|/', s_operator),
  572.             ('\\s+', None)])
  573.         self.assertNotEqual(scanner.scanner.scanner('').pattern, None)
  574.         self.assertEqual(scanner.scan('sum = 3*foo + 312.50 + bar'), ([
  575.             'sum',
  576.             'op=',
  577.             3,
  578.             'op*',
  579.             'foo',
  580.             'op+',
  581.             312.5,
  582.             'op+',
  583.             'bar'], ''))
  584.  
  585.     
  586.     def test_bug_448951(self):
  587.         for op in ('', '?', '*'):
  588.             self.assertEqual(re.match('((.%s):)?z' % op, 'z').groups(), (None, None))
  589.             self.assertEqual(re.match('((.%s):)?z' % op, 'a:z').groups(), ('a:', 'a'))
  590.         
  591.  
  592.     
  593.     def test_bug_725106(self):
  594.         self.assertEqual(re.match('^((a)|b)*', 'abc').groups(), ('b', 'a'))
  595.         self.assertEqual(re.match('^(([ab])|c)*', 'abc').groups(), ('c', 'b'))
  596.         self.assertEqual(re.match('^((d)|[ab])*', 'abc').groups(), ('b', None))
  597.         self.assertEqual(re.match('^((a)c|[ab])*', 'abc').groups(), ('b', None))
  598.         self.assertEqual(re.match('^((a)|b)*?c', 'abc').groups(), ('b', 'a'))
  599.         self.assertEqual(re.match('^(([ab])|c)*?d', 'abcd').groups(), ('c', 'b'))
  600.         self.assertEqual(re.match('^((d)|[ab])*?c', 'abc').groups(), ('b', None))
  601.         self.assertEqual(re.match('^((a)c|[ab])*?c', 'abc').groups(), ('b', None))
  602.  
  603.     
  604.     def test_bug_725149(self):
  605.         self.assertEqual(re.match('(a)(?:(?=(b)*)c)*', 'abb').groups(), ('a', None))
  606.         self.assertEqual(re.match('(a)((?!(b)*))*', 'abb').groups(), ('a', None, None))
  607.  
  608.     
  609.     def test_bug_764548(self):
  610.         
  611.         try:
  612.             unicode
  613.         except NameError:
  614.             return None
  615.  
  616.         
  617.         class my_unicode(unicode):
  618.             pass
  619.  
  620.         pat = re.compile(my_unicode('abc'))
  621.         self.assertEqual(pat.match('xyz'), None)
  622.  
  623.     
  624.     def test_finditer(self):
  625.         iter = re.finditer(':+', 'a:b::c:::d')
  626.         []([ item.group(0) for item in iter ], [
  627.             ':',
  628.             '::',
  629.             ':::'])
  630.  
  631.     
  632.     def test_bug_926075(self):
  633.         
  634.         try:
  635.             unicode
  636.         except NameError:
  637.             return None
  638.  
  639.         self.assert_(re.compile('bug_926075') is not re.compile(eval("u'bug_926075'")))
  640.  
  641.     
  642.     def test_bug_931848(self):
  643.         
  644.         try:
  645.             unicode
  646.         except NameError:
  647.             pass
  648.  
  649.         pattern = eval('u"[\\u002E\\u3002\\uFF0E\\uFF61]"')
  650.         self.assertEqual(re.compile(pattern).split('a.b.c'), [
  651.             'a',
  652.             'b',
  653.             'c'])
  654.  
  655.     
  656.     def test_bug_581080(self):
  657.         iter = re.finditer('\\s', 'a b')
  658.         self.assertEqual(iter.next().span(), (1, 2))
  659.         self.assertRaises(StopIteration, iter.next)
  660.         scanner = re.compile('\\s').scanner('a b')
  661.         self.assertEqual(scanner.search().span(), (1, 2))
  662.         self.assertEqual(scanner.search(), None)
  663.  
  664.     
  665.     def test_bug_817234(self):
  666.         iter = re.finditer('.*', 'asdf')
  667.         self.assertEqual(iter.next().span(), (0, 4))
  668.         self.assertEqual(iter.next().span(), (4, 4))
  669.         self.assertRaises(StopIteration, iter.next)
  670.  
  671.  
  672.  
  673. def run_re_tests():
  674.     benchmarks = benchmarks
  675.     tests = tests
  676.     SUCCEED = SUCCEED
  677.     FAIL = FAIL
  678.     SYNTAX_ERROR = SYNTAX_ERROR
  679.     import test.re_tests
  680.     if verbose:
  681.         print 'Running re_tests test suite'
  682.     
  683.     for t in tests:
  684.         sys.stdout.flush()
  685.         pattern = None
  686.         s = None
  687.         outcome = None
  688.         repl = None
  689.         expected = None
  690.         if len(t) == 5:
  691.             (pattern, s, outcome, repl, expected) = t
  692.         elif len(t) == 3:
  693.             (pattern, s, outcome) = t
  694.         else:
  695.             raise ValueError, ('Test tuples should have 3 or 5 fields', t)
  696.         
  697.         try:
  698.             obj = re.compile(pattern)
  699.         except re.error:
  700.             if outcome == SYNTAX_ERROR:
  701.                 pass
  702.             else:
  703.                 print '=== Syntax error:', t
  704.             outcome == SYNTAX_ERROR
  705.             except KeyboardInterrupt:
  706.                 raise KeyboardInterrupt
  707.                 continue
  708.                 print '*** Unexpected error ***', t
  709.                 if verbose:
  710.                     traceback.print_exc(file = sys.stdout)
  711.                 
  712.             else:
  713.                 
  714.                 try:
  715.                     result = obj.search(s)
  716.                 except re.error:
  717.                     verbose
  718.                     msg = verbose
  719.                     print '=== Unexpected exception', t, repr(msg)
  720.                 except:
  721.                     verbose
  722.  
  723.                 if outcome == SYNTAX_ERROR:
  724.                     continue
  725.  
  726.         verbose
  727.         if outcome == FAIL:
  728.             if result is None:
  729.                 pass
  730.             else:
  731.                 print '=== Succeeded incorrectly', t
  732.         result is None
  733.         if outcome == SUCCEED:
  734.             if result is not None:
  735.                 (start, end) = result.span(0)
  736.                 vardict = {
  737.                     'found': result.group(0),
  738.                     'groups': result.group(),
  739.                     'flags': result.re.flags }
  740.                 for i in range(1, 100):
  741.                     
  742.                     try:
  743.                         gi = result.group(i)
  744.                         if gi is None:
  745.                             gi = 'None'
  746.                     except IndexError:
  747.                         gi = 'Error'
  748.  
  749.                     vardict['g%d' % i] = gi
  750.                 
  751.                 for i in result.re.groupindex.keys():
  752.                     
  753.                     try:
  754.                         gi = result.group(i)
  755.                         if gi is None:
  756.                             gi = 'None'
  757.                     except IndexError:
  758.                         gi = 'Error'
  759.  
  760.                     vardict[i] = gi
  761.                 
  762.                 repl = eval(repl, vardict)
  763.                 if repl != expected:
  764.                     print '=== grouping error', t, repr(repl) + ' should be ' + repr(expected)
  765.                 
  766.             else:
  767.                 print '=== Failed incorrectly', t
  768.             
  769.             try:
  770.                 result = obj.search(unicode(s, 'latin-1'))
  771.                 if result is None:
  772.                     print '=== Fails on unicode match', t
  773.             except NameError:
  774.                 continue
  775.             except TypeError:
  776.                 continue
  777.  
  778.             obj = re.compile(unicode(pattern, 'latin-1'))
  779.             result = obj.search(s)
  780.             if result is None:
  781.                 print '=== Fails on unicode pattern match', t
  782.             
  783.             if pattern[:2] != '\\B' and pattern[-2:] != '\\B' and result is not None:
  784.                 obj = re.compile(pattern)
  785.                 result = obj.search(s, result.start(0), result.end(0) + 1)
  786.                 if result is None:
  787.                     print '=== Failed on range-limited match', t
  788.                 
  789.             
  790.             obj = re.compile(pattern, re.IGNORECASE)
  791.             result = obj.search(s)
  792.             if result is None:
  793.                 print '=== Fails on case-insensitive match', t
  794.             
  795.             obj = re.compile(pattern, re.LOCALE)
  796.             result = obj.search(s)
  797.             if result is None:
  798.                 print '=== Fails on locale-sensitive match', t
  799.             
  800.             obj = re.compile(pattern, re.UNICODE)
  801.             result = obj.search(s)
  802.             if result is None:
  803.                 print '=== Fails on unicode-sensitive match', t
  804.             
  805.         result is None
  806.     
  807.  
  808.  
  809. def test_main():
  810.     run_unittest(ReTests)
  811.     run_re_tests()
  812.  
  813. if __name__ == '__main__':
  814.     test_main()
  815.  
  816.